package com.share51.novel.init;

import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import com.share51.novel.common.StatusConstant;
import com.share51.novel.entity.Category;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 应用数据缓存
 *
 * @author gb
 */
public class ApplicationCached {

    /**
     * 服务器初始化状态 若是 false 则初始化成功 true 初始化中
     */
    public static boolean SERVER_IS_INIT=false;

    /**
     * crawl 加入到过滤器的url
     */
    private static BloomFilter<String> CRAWL_FILTER;

    /**
     * 小说章节 加入到过滤器中url
     */
    private static BloomFilter<String> CHAPTER_URL_FILTER;

    static {
        reset();
    }

    private static void reset(){
        CRAWL_FILTER=BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), 200000, 1E-7);
        CHAPTER_URL_FILTER=BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), 1000000, 1E-7);
    }

    /**
     * 初始化布隆过滤器
     * @param crawlUrlList crawl表中url（前缀必须是site字段）
     * @param chapterUrlList chapter表中url（前缀必须是site字段）
     */
    public static void initBloomFilter(List<String> crawlUrlList,List<String> chapterUrlList){
        reset();
        crawlUrlList.forEach(CRAWL_FILTER::put);
        chapterUrlList.forEach(CHAPTER_URL_FILTER::put);
    }

    /**
     * 判断是否爬取过此小说
     * @param crawlUrl crawl表中url（前缀必须是site字段）
     * @return
     */
    public static boolean existCrawlUrl(String crawlUrl){
       return CRAWL_FILTER.mightContain(crawlUrl);
    }
    public static void addCrawlUrl(String crawlUrl){
        CRAWL_FILTER.put(crawlUrl);
    }

    /**
     * 判断是否爬取过小说章节
     * @param chapterUrl chapter表中url（前缀必须是site字段）
     * @return
     */
    public static boolean existChapterUrl(String chapterUrl){
        return CHAPTER_URL_FILTER.mightContain(chapterUrl);
    }
    public static void addChapterUrl(String chapterUrl){
        CHAPTER_URL_FILTER.put(chapterUrl);
    }
    public static void addAllChapterUrl(List<String> chapterUrlList) {
        chapterUrlList.forEach(CHAPTER_URL_FILTER::put);
    }

    /**
     * 默认的其他类型的分类 0
     */
    private static final int OTHER_CATEGORY_VAL=0;

    /**
     * 缓存 分类数据 主要用于爬虫爬取到小说后对小说归类
     */
    private static final Map<String, Integer> CATEGORY_CACHED = new ConcurrentHashMap<>();

    /**
     * 缓存 分类数据 主要是为了前端页面加载栏目列表
     */
    private static final List<CategoryVo> CATEGORY_BANNER_CACHE = new ArrayList<>();

    /**
     * 获取首页栏目列表
     * @return
     */
    public static ImmutableList<CategoryVo> getMenuList(){
        return ImmutableList.copyOf(CATEGORY_BANNER_CACHE);
    }


    public static Integer getCategoryCode(String categoryName){
        String key = CATEGORY_CACHED
                .keySet()
                .stream()
                .filter(name -> name.contains(categoryName)||categoryName.contains(name))
                .findFirst()
                .orElse(null);
        if (StringUtils.isBlank(key)){
            return OTHER_CATEGORY_VAL;
        }
        return CATEGORY_CACHED.get(key);
    }

    static void initCategory(List<Category> list) {
        list.sort((o1, o2) -> {
            if (o1.getOrderIndex() < o2.getOrderIndex()) {
                return -1;
            } else if (o1.getOrderIndex() > o2.getOrderIndex()) {
                return 1;
            } else {
                return 0;
            }
        });
        list.forEach(category->{
            CATEGORY_CACHED.put(category.getName(), category.getId());
            if (StatusConstant.STATUS_OK == category.getStatus()) {
                CATEGORY_BANNER_CACHE.add(new CategoryVo(category));
            }
        });
    }


}
